package Easy;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

public class Easy {

    public static void main(String[] args) {

        int A = 'b' - 'a';

        System.out.println(A);

    }


    /** TODO 判断字符是否唯一
     * 实现一个算法，确定一个字符串 s 的所有字符是否全都不同。
     * 示例 1：
     * 输入: s = "leetcode"
     * 输出: false
     * 示例 2：
     *
     * 输入: s = "abc"
     * 输出: true
     * 限制：
     *
     * 0 <= len(s) <= 100
     * s[i]仅包含小写字母
     * 如果你不使用额外的数据结构，会很加分。
     * */

    /**
     * 解题思路：
     * 1.先把字符串转换成字符数组，
     * 2.sort()排序，排序后每一位元素只可能和它前一位或后一位相同，
     * 3.循环遍历char[i]和char[i+1]判断是否相等，
     * 相等直接返回false,不相等i++,如果遍历结束没有相同，返回true。
     * */

    public static boolean isUnique(String astr) {

        char[] charArray = astr.toCharArray();

        Arrays.sort(charArray);

        boolean booStr = true;

        for (int i = 0; i < charArray.length-1; i++) {

            if (charArray[i] == charArray[i+1]){
                booStr = false;
            }
        }

        return booStr;
    }




    /**
     * TODO 判定是否互为字符重排
     * 1.字符串s1和s2互为字符重排 等价于「两个字符串排序后相等」sort,
     * 2.因此我们可以对字符串s1和s2分别排序，看排序后的字符串是否相等即可判断,
     * 3.如果长度不同 就已经必然不是异位词
     * */
    public static boolean CheckPermutation(String s1, String s2) {
        if (s1.length() != s2.length()){
            return false;
        }

        char[] charArray1 = s1.toCharArray();
        char[] charArray2 = s2.toCharArray();

        Arrays.sort(charArray1);
        Arrays.sort(charArray2);

        return Arrays.equals(charArray1,charArray2);
    }

    /**
     * 空格URL化
     * 1.将字符串放到一个新的字符数组中，
     * 2.当碰到空格字符时依次填入%20
     * */
    public static String replaceSpaces(String S, int length) {

        // 极端情况下length个字符都是' '，替换后数组中存放length个"%20"
        char[] chars = new char[length * 3];
        int index=0;
        for (int i =0; i<=length-1; i++) {
            if (S.charAt(i) == ' '){
                chars[index++] = '%' ;
                chars[index++] = '2' ;
                chars[index++] = '0' ;
            }else {
                chars[index++]=S.charAt(i);
            }
        }
        return new String(chars);

//        char[] cs = new char[length * 3];
//        int i = 0, j = 0;
//        char c;
//        while(i < length){
//            c = S.charAt(i);
//            if(c == ' '){
//                cs[j++] = '%';
//                cs[j++] = '2';
//                cs[j++] = '0';
//            } else {
//                cs[j++] = c;
//            }
//            i++;
//        }
//        return new String(cs, 0, j);
    }


    /**
     * 回文排列
     * 回文字符串有两种，一种是奇数的，类似于"abbba"，一种是偶数的，类似于"abba"或者"aabbaa"
     * 偶数的好判断，只需要找出每个字符都是偶数就行了。但奇数的就不能使用这种方式了，
     * 如果是奇数的，那么字符串的所有字符中只有一个字符的个数是奇数，其他的都是偶数。
     * */
    public static boolean canPermutePalindrome(String s) {
        Set<Character> set = new HashSet<>();
        char[] chars = s.toCharArray();

        for (char aChar : chars) {
            //set的add方法如果返回false，表示已经有了，
            if (!set.add(aChar)){
                //我们就把他删除
                set.remove(aChar);
            }
        }

        //最后判断set的长度是否小于等于1
        //如果等于1,说明只有一个字符的个数是奇数，其他的都是偶数
        //如果等于0,说明每个字符都是偶数，否则不可能构成回文字符串
        return  set.size()<=1;
    }


    /**
     * 交替合并字符串
     *给你两个字符串 word1 和 word2 。请你从 word1 开始，通过交替添加字母来合并字符串。如果一个字符串比另一个字符串长，就将多出来的字母追加到合并后字符串的末尾。
     * 返回 合并后的字符串
     * 示例 1：
     * 输入：word1 = "abc", word2 = "pqr"
     * 输出："apbqcr"
     * 解释：字符串合并情况如下所示：
     * word1：  a   b   c
     * word2：    p   q   r
     * 合并后：  a p b q c r
     *
     *
     * */
    public static String mergeAlternately(String word1, String word2) {
        int len1 = word1.length();
        int len2 = word2.length();

        StringBuilder ans = new StringBuilder(len1 + len2);

        for (int i = 0; i < len1 || i<len2; i++) {
            if (i<=len1) ans.append(word1.toCharArray()[i]);

            if (i<=len2) ans.append(word2.toCharArray()[i]);
        }
        return ans.toString();
    }




    /**
     *  找不同
     *
     *  另辟蹊径 ：把Char转成数字求和，再求差值，强转回char
     *
     * */


    public char findTheDifference(String s, String t) {

        return (char)(Math.abs(sumChar(s) - sumChar(t)));

    }

    //把Char转成数字求和
    public int sumChar(String str){
        int sum = 0;
        for(char c : str.toCharArray()){
            sum += (int)c;
        }
        return sum;
    }





    public static char findTheDifferenceFail(String s, String t) {

        char[] sc = s.toCharArray();
        char[] tc = t.toCharArray();

        char theDiff = 0;

        Set<Character> set = new HashSet<>();

        for (int i = 0; i < sc.length; i++) {
            set.add(sc[i]);
        }

        for (int i = 0; i < tc.length; i++) {
            if (set.add(tc[i])){
                theDiff= tc[i];
            }
        }

        return theDiff;
    }
}
